@photonix/basic 1.5.1 → 1.6.1

package/dist/chunk-QJ537P3Q.mjs

@@ -0,0 +1,92 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/gherkin.js
+gherkin.displayName = "gherkin";
+gherkin.aliases = [];
+function gherkin(Prism) {
+  ;
+  (function(Prism2) {
+    var tableRow = /(?:\r?\n|\r)[ \t]*\|.+\|(?:(?!\|).)*/.source;
+    Prism2.languages.gherkin = {
+      pystring: {
+        pattern: /("""|''')[\s\S]+?\1/,
+        alias: "string"
+      },
+      comment: {
+        pattern: /(^[ \t]*)#.*/m,
+        lookbehind: true
+      },
+      tag: {
+        pattern: /(^[ \t]*)@\S*/m,
+        lookbehind: true
+      },
+      feature: {
+        pattern: /((?:^|\r?\n|\r)[ \t]*)(?:Ability|Ahoy matey!|Arwedd|Aspekt|Besigheid Behoefte|Business Need|Caracteristica|Característica|Egenskab|Egenskap|Eiginleiki|Feature|Fīča|Fitur|Fonctionnalité|Fonksyonalite|Funcionalidade|Funcionalitat|Functionalitate|Funcţionalitate|Funcționalitate|Functionaliteit|Fungsi|Funkcia|Funkcija|Funkcionalitāte|Funkcionalnost|Funkcja|Funksie|Funktionalität|Funktionalitéit|Funzionalità|Hwaet|Hwæt|Jellemző|Karakteristik|Lastnost|Mak|Mogucnost|laH|Mogućnost|Moznosti|Možnosti|OH HAI|Omadus|Ominaisuus|Osobina|Özellik|Potrzeba biznesowa|perbogh|poQbogh malja'|Požadavek|Požiadavka|Pretty much|Qap|Qu'meH 'ut|Savybė|Tính năng|Trajto|Vermoë|Vlastnosť|Właściwość|Značilnost|Δυνατότητα|Λειτουργία|Могућност|Мөмкинлек|Особина|Свойство|Үзенчәлеклелек|Функционал|Функционалност|Функция|Функціонал|תכונה|خاصية|خصوصیت|صلاحیت|کاروبار کی ضرورت|وِیژگی|रूप लेख|ਖਾਸੀਅਤ|ਨਕਸ਼ ਨੁਹਾਰ|ਮੁਹਾਂਦਰਾ|గుణము|ಹೆಚ್ಚಳ|ความต้องการทางธุรกิจ|ความสามารถ|โครงหลัก|기능|フィーチャ|功能|機能):(?:[^:\r\n]+(?:\r?\n|\r|$))*/,
+        lookbehind: true,
+        inside: {
+          important: {
+            pattern: /(:)[^\r\n]+/,
+            lookbehind: true
+          },
+          keyword: /[^:\r\n]+:/
+        }
+      },
+      scenario: {
+        pattern: /(^[ \t]*)(?:Abstract Scenario|Abstrakt Scenario|Achtergrond|Aer|Ær|Agtergrond|All y'all|Antecedentes|Antecedents|Atburðarás|Atburðarásir|Awww, look mate|B4|Background|Baggrund|Bakgrund|Bakgrunn|Bakgrunnur|Beispiele|Beispiller|Bối cảnh|Cefndir|Cenario|Cenário|Cenario de Fundo|Cenário de Fundo|Cenarios|Cenários|Contesto|Context|Contexte|Contexto|Conto|Contoh|Contone|Dæmi|Dasar|Dead men tell no tales|Delineacao do Cenario|Delineação do Cenário|Dis is what went down|Dữ liệu|Dyagram Senaryo|Dyagram senaryo|Egzanp|Ejemplos|Eksempler|Ekzemploj|Enghreifftiau|Esbozo do escenario|Escenari|Escenario|Esempi|Esquema de l'escenari|Esquema del escenario|Esquema do Cenario|Esquema do Cenário|EXAMPLZ|Examples|Exempel|Exemple|Exemples|Exemplos|First off|Fono|Forgatókönyv|Forgatókönyv vázlat|Fundo|Geçmiş|Grundlage|Hannergrond|ghantoH|Háttér|Heave to|Istorik|Juhtumid|Keadaan|Khung kịch bản|Khung tình huống|Kịch bản|Koncept|Konsep skenario|Kontèks|Kontekst|Kontekstas|Konteksts|Kontext|Konturo de la scenaro|Latar Belakang|lut chovnatlh|lut|lutmey|Lýsing Atburðarásar|Lýsing Dæma|MISHUN SRSLY|MISHUN|Menggariskan Senario|mo'|Náčrt Scenára|Náčrt Scénáře|Náčrt Scenáru|Oris scenarija|Örnekler|Osnova|Osnova Scenára|Osnova scénáře|Osnutek|Ozadje|Paraugs|Pavyzdžiai|Példák|Piemēri|Plan du scénario|Plan du Scénario|Plan Senaryo|Plan senaryo|Plang vum Szenario|Pozadí|Pozadie|Pozadina|Príklady|Příklady|Primer|Primeri|Primjeri|Przykłady|Raamstsenaarium|Reckon it's like|Rerefons|Scenár|Scénář|Scenarie|Scenarij|Scenarijai|Scenarijaus šablonas|Scenariji|Scenārijs|Scenārijs pēc parauga|Scenarijus|Scenario|Scénario|Scenario Amlinellol|Scenario Outline|Scenario Template|Scenariomal|Scenariomall|Scenarios|Scenariu|Scenariusz|Scenaro|Schema dello scenario|Se ðe|Se the|Se þe|Senario|Senaryo Deskripsyon|Senaryo deskripsyon|Senaryo|Senaryo taslağı|Shiver me timbers|Situācija|Situai|Situasie Uiteensetting|Situasie|Skenario konsep|Skenario|Skica|Structura scenariu|Structură scenariu|Struktura scenarija|Stsenaarium|Swa hwaer swa|Swa|Swa hwær swa|Szablon scenariusza|Szenario|Szenariogrundriss|Tapaukset|Tapaus|Tapausaihio|Taust|Tausta|Template Keadaan|Template Senario|Template Situai|The thing of it is|Tình huống|Variantai|Voorbeelde|Voorbeelden|Wharrimean is|Yo-ho-ho|You'll wanna|Założenia|Παραδείγματα|Περιγραφή Σεναρίου|Σενάρια|Σενάριο|Υπόβαθρο|Кереш|Контекст|Концепт|Мисаллар|Мисоллар|Основа|Передумова|Позадина|Предистория|Предыстория|Приклади|Пример|Примери|Примеры|Рамка на сценарий|Скица|Структура сценарија|Структура сценария|Структура сценарію|Сценарий|Сценарий структураси|Сценарийның төзелеше|Сценарији|Сценарио|Сценарій|Тарих|Үрнәкләр|דוגמאות|רקע|תבנית תרחיש|תרחיש|الخلفية|الگوی سناریو|امثلة|پس منظر|زمینه|سناریو|سيناريو|سيناريو مخطط|مثالیں|منظر نامے کا خاکہ|منظرنامہ|نمونه ها|उदाहरण|परिदृश्य|परिदृश्य रूपरेखा|पृष्ठभूमि|ਉਦਾਹਰਨਾਂ|ਪਟਕਥਾ|ਪਟਕਥਾ ਢਾਂਚਾ|ਪਟਕਥਾ ਰੂਪ ਰੇਖਾ|ਪਿਛੋਕੜ|ఉదాహరణలు|కథనం|నేపథ్యం|సన్నివేశం|ಉದಾಹರಣೆಗಳು|ಕಥಾಸಾರಾಂಶ|ವಿವರಣೆ|ಹಿನ್ನೆಲೆ|โครงสร้างของเหตุการณ์|ชุดของตัวอย่าง|ชุดของเหตุการณ์|แนวคิด|สรุปเหตุการณ์|เหตุการณ์|배경|시나리오|시나리오 개요|예|サンプル|シナリオ|シナリオアウトライン|シナリオテンプレ|シナリオテンプレート|テンプレ|例|例子|剧本|剧本大纲|劇本|劇本大綱|场景|场景大纲|場景|場景大綱|背景):[^:\r\n]*/m,
+        lookbehind: true,
+        inside: {
+          important: {
+            pattern: /(:)[^\r\n]*/,
+            lookbehind: true
+          },
+          keyword: /[^:\r\n]+:/
+        }
+      },
+      "table-body": {
+        // Look-behind is used to skip the table head, which has the same format as any table row
+        pattern: RegExp("(" + tableRow + ")(?:" + tableRow + ")+"),
+        lookbehind: true,
+        inside: {
+          outline: {
+            pattern: /<[^>]+>/,
+            alias: "variable"
+          },
+          td: {
+            pattern: /\s*[^\s|][^|]*/,
+            alias: "string"
+          },
+          punctuation: /\|/
+        }
+      },
+      "table-head": {
+        pattern: RegExp(tableRow),
+        inside: {
+          th: {
+            pattern: /\s*[^\s|][^|]*/,
+            alias: "variable"
+          },
+          punctuation: /\|/
+        }
+      },
+      atrule: {
+        pattern: /(^[ \t]+)(?:'a|'ach|'ej|7|a|A také|A taktiež|A tiež|A zároveň|Aber|Ac|Adott|Akkor|Ak|Aleshores|Ale|Ali|Allora|Alors|Als|Ama|Amennyiben|Amikor|Ampak|an|AN|Ananging|And y'all|And|Angenommen|Anrhegedig a|An|Apabila|Atès|Atesa|Atunci|Avast!|Aye|A|awer|Bagi|Banjur|Bet|Biết|Blimey!|Buh|But at the end of the day I reckon|But y'all|But|BUT|Cal|Când|Cand|Cando|Ce|Cuando|Če|Ða ðe|Ða|Dadas|Dada|Dados|Dado|DaH ghu' bejlu'|dann|Dann|Dano|Dan|Dar|Dat fiind|Data|Date fiind|Date|Dati fiind|Dati|Daţi fiind|Dați fiind|DEN|Dato|De|Den youse gotta|Dengan|Diberi|Diyelim ki|Donada|Donat|Donitaĵo|Do|Dun|Duota|Ðurh|Eeldades|Ef|Eğer ki|Entao|Então|Entón|E|En|Entonces|Epi|És|Etant donnée|Etant donné|Et|Étant données|Étant donnée|Étant donné|Etant données|Etant donnés|Étant donnés|Fakat|Gangway!|Gdy|Gegeben seien|Gegeben sei|Gegeven|Gegewe|ghu' noblu'|Gitt|Given y'all|Given|Givet|Givun|Ha|Cho|I CAN HAZ|In|Ir|It's just unbelievable|I|Ja|Jeśli|Jeżeli|Kad|Kada|Kadar|Kai|Kaj|Když|Keď|Kemudian|Ketika|Khi|Kiedy|Ko|Kuid|Kui|Kun|Lan|latlh|Le sa a|Let go and haul|Le|Lè sa a|Lè|Logo|Lorsqu'<|Lorsque|mä|Maar|Mais|Mając|Ma|Majd|Maka|Manawa|Mas|Men|Menawa|Mutta|Nalika|Nalikaning|Nanging|Når|När|Nato|Nhưng|Niin|Njuk|O zaman|Och|Og|Oletetaan|Ond|Onda|Oraz|Pak|Pero|Però|Podano|Pokiaľ|Pokud|Potem|Potom|Privzeto|Pryd|Quan|Quand|Quando|qaSDI'|Så|Sed|Se|Siis|Sipoze ke|Sipoze Ke|Sipoze|Si|Şi|Și|Soit|Stel|Tada|Tad|Takrat|Tak|Tapi|Ter|Tetapi|Tha the|Tha|Then y'all|Then|Thì|Thurh|Toda|Too right|Un|Und|ugeholl|Và|vaj|Vendar|Ve|wann|Wanneer|WEN|Wenn|When y'all|When|Wtedy|Wun|Y'know|Yeah nah|Yna|Youse know like when|Youse know when youse got|Y|Za predpokladu|Za předpokladu|Zadan|Zadani|Zadano|Zadate|Zadato|Zakładając|Zaradi|Zatati|Þa þe|Þa|Þá|Þegar|Þurh|Αλλά|Δεδομένου|Και|Όταν|Τότε|А також|Агар|Але|Али|Аммо|А|Әгәр|Әйтик|Әмма|Бирок|Ва|Вә|Дадено|Дано|Допустим|Если|Задате|Задати|Задато|И|І|К тому же|Када|Кад|Когато|Когда|Коли|Ләкин|Лекин|Нәтиҗәдә|Нехай|Но|Онда|Припустимо, що|Припустимо|Пусть|Также|Та|Тогда|Тоді|То|Унда|Һәм|Якщо|אבל|אזי|אז|בהינתן|וגם|כאשר|آنگاه|اذاً|اگر|اما|اور|با فرض|بالفرض|بفرض|پھر|تب|ثم|جب|عندما|فرض کیا|لكن|لیکن|متى|هنگامی|و|अगर|और|कदा|किन्तु|चूंकि|जब|तथा|तदा|तब|परन्तु|पर|यदि|ਅਤੇ|ਜਦੋਂ|ਜਿਵੇਂ ਕਿ|ਜੇਕਰ|ਤਦ|ਪਰ|అప్పుడు|ఈ పరిస్థితిలో|కాని|చెప్పబడినది|మరియు|ಆದರೆ|ನಂತರ|ನೀಡಿದ|ಮತ್ತು|ಸ್ಥಿತಿಯನ್ನು|กำหนดให้|ดังนั้น|แต่|เมื่อ|และ|그러면<|그리고<|단<|만약<|만일<|먼저<|조건<|하지만<|かつ<|しかし<|ただし<|ならば<|もし<|並且<|但し<|但是<|假如<|假定<|假設<|假设<|前提<|同时<|同時<|并且<|当<|當<|而且<|那么<|那麼<)(?=[ \t])/m,
+        lookbehind: true
+      },
+      string: {
+        pattern: /"(?:\\.|[^"\\\r\n])*"|'(?:\\.|[^'\\\r\n])*'/,
+        inside: {
+          outline: {
+            pattern: /<[^>]+>/,
+            alias: "variable"
+          }
+        }
+      },
+      outline: {
+        pattern: /<[^>]+>/,
+        alias: "variable"
+      }
+    };
+  })(Prism);
+}
+
+export {
+  gherkin
+};

package/dist/chunk-QMLVGGWT.mjs

@@ -0,0 +1,96 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/yaml.js
+yaml.displayName = "yaml";
+yaml.aliases = ["yml"];
+function yaml(Prism) {
+  ;
+  (function(Prism2) {
+    var anchorOrAlias = /[*&][^\s[\]{},]+/;
+    var tag = /!(?:<[\w\-%#;/?:@&=+$,.!~*'()[\]]+>|(?:[a-zA-Z\d-]*!)?[\w\-%#;/?:@&=+$.~*'()]+)?/;
+    var properties = "(?:" + tag.source + "(?:[ 	]+" + anchorOrAlias.source + ")?|" + anchorOrAlias.source + "(?:[ 	]+" + tag.source + ")?)";
+    var plainKey = /(?:[^\s\x00-\x08\x0e-\x1f!"#%&'*,\-:>?@[\]`{|}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]|[?:-]<PLAIN>)(?:[ \t]*(?:(?![#:])<PLAIN>|:<PLAIN>))*/.source.replace(
+      /<PLAIN>/g,
+      function() {
+        return /[^\s\x00-\x08\x0e-\x1f,[\]{}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]/.source;
+      }
+    );
+    var string = /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/.source;
+    function createValuePattern(value, flags) {
+      flags = (flags || "").replace(/m/g, "") + "m";
+      var pattern = /([:\-,[{]\s*(?:\s<<prop>>[ \t]+)?)(?:<<value>>)(?=[ \t]*(?:$|,|\]|\}|(?:[\r\n]\s*)?#))/.source.replace(/<<prop>>/g, function() {
+        return properties;
+      }).replace(/<<value>>/g, function() {
+        return value;
+      });
+      return RegExp(pattern, flags);
+    }
+    Prism2.languages.yaml = {
+      scalar: {
+        pattern: RegExp(
+          /([\-:]\s*(?:\s<<prop>>[ \t]+)?[|>])[ \t]*(?:((?:\r?\n|\r)[ \t]+)\S[^\r\n]*(?:\2[^\r\n]+)*)/.source.replace(
+            /<<prop>>/g,
+            function() {
+              return properties;
+            }
+          )
+        ),
+        lookbehind: true,
+        alias: "string"
+      },
+      comment: /#.*/,
+      key: {
+        pattern: RegExp(
+          /((?:^|[:\-,[{\r\n?])[ \t]*(?:<<prop>>[ \t]+)?)<<key>>(?=\s*:\s)/.source.replace(/<<prop>>/g, function() {
+            return properties;
+          }).replace(/<<key>>/g, function() {
+            return "(?:" + plainKey + "|" + string + ")";
+          })
+        ),
+        lookbehind: true,
+        greedy: true,
+        alias: "atrule"
+      },
+      directive: {
+        pattern: /(^[ \t]*)%.+/m,
+        lookbehind: true,
+        alias: "important"
+      },
+      datetime: {
+        pattern: createValuePattern(
+          /\d{4}-\d\d?-\d\d?(?:[tT]|[ \t]+)\d\d?:\d{2}:\d{2}(?:\.\d*)?(?:[ \t]*(?:Z|[-+]\d\d?(?::\d{2})?))?|\d{4}-\d{2}-\d{2}|\d\d?:\d{2}(?::\d{2}(?:\.\d*)?)?/.source
+        ),
+        lookbehind: true,
+        alias: "number"
+      },
+      boolean: {
+        pattern: createValuePattern(/false|true/.source, "i"),
+        lookbehind: true,
+        alias: "important"
+      },
+      null: {
+        pattern: createValuePattern(/null|~/.source, "i"),
+        lookbehind: true,
+        alias: "important"
+      },
+      string: {
+        pattern: createValuePattern(string),
+        lookbehind: true,
+        greedy: true
+      },
+      number: {
+        pattern: createValuePattern(
+          /[+-]?(?:0x[\da-f]+|0o[0-7]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|\.inf|\.nan)/.source,
+          "i"
+        ),
+        lookbehind: true
+      },
+      tag,
+      important: anchorOrAlias,
+      punctuation: /---|[:[\]{}\-,|>?]|\.\.\./
+    };
+    Prism2.languages.yml = Prism2.languages.yaml;
+  })(Prism);
+}
+
+export {
+  yaml
+};

package/dist/chunk-QTQHLTTA.mjs

@@ -0,0 +1,37 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/visual-basic.js
+visualBasic.displayName = "visual-basic";
+visualBasic.aliases = ["vb", "vba"];
+function visualBasic(Prism) {
+  Prism.languages["visual-basic"] = {
+    comment: {
+      pattern: /(?:['‘’]|REM\b)(?:[^\r\n_]|_(?:\r\n?|\n)?)*/i,
+      inside: {
+        keyword: /^REM/i
+      }
+    },
+    directive: {
+      pattern: /#(?:Const|Else|ElseIf|End|ExternalChecksum|ExternalSource|If|Region)(?:\b_[ \t]*(?:\r\n?|\n)|.)+/i,
+      alias: "property",
+      greedy: true
+    },
+    string: {
+      pattern: /\$?["“”](?:["“”]{2}|[^"“”])*["“”]C?/i,
+      greedy: true
+    },
+    date: {
+      pattern: /#[ \t]*(?:\d+([/-])\d+\1\d+(?:[ \t]+(?:\d+[ \t]*(?:AM|PM)|\d+:\d+(?::\d+)?(?:[ \t]*(?:AM|PM))?))?|\d+[ \t]*(?:AM|PM)|\d+:\d+(?::\d+)?(?:[ \t]*(?:AM|PM))?)[ \t]*#/i,
+      alias: "number"
+    },
+    number: /(?:(?:\b\d+(?:\.\d+)?|\.\d+)(?:E[+-]?\d+)?|&[HO][\dA-F]+)(?:[FRD]|U?[ILS])?/i,
+    boolean: /\b(?:False|Nothing|True)\b/i,
+    keyword: /\b(?:AddHandler|AddressOf|Alias|And(?:Also)?|As|Boolean|ByRef|Byte|ByVal|Call|Case|Catch|C(?:Bool|Byte|Char|Date|Dbl|Dec|Int|Lng|Obj|SByte|Short|Sng|Str|Type|UInt|ULng|UShort)|Char|Class|Const|Continue|Currency|Date|Decimal|Declare|Default|Delegate|Dim|DirectCast|Do|Double|Each|Else(?:If)?|End(?:If)?|Enum|Erase|Error|Event|Exit|Finally|For|Friend|Function|Get(?:Type|XMLNamespace)?|Global|GoSub|GoTo|Handles|If|Implements|Imports|In|Inherits|Integer|Interface|Is|IsNot|Let|Lib|Like|Long|Loop|Me|Mod|Module|Must(?:Inherit|Override)|My(?:Base|Class)|Namespace|Narrowing|New|Next|Not(?:Inheritable|Overridable)?|Object|Of|On|Operator|Option(?:al)?|Or(?:Else)?|Out|Overloads|Overridable|Overrides|ParamArray|Partial|Private|Property|Protected|Public|RaiseEvent|ReadOnly|ReDim|RemoveHandler|Resume|Return|SByte|Select|Set|Shadows|Shared|short|Single|Static|Step|Stop|String|Structure|Sub|SyncLock|Then|Throw|To|Try|TryCast|Type|TypeOf|U(?:Integer|Long|Short)|Until|Using|Variant|Wend|When|While|Widening|With(?:Events)?|WriteOnly|Xor)\b/i,
+    operator: /[+\-*/\\^<=>&#@$%!]|\b_(?=[ \t]*[\r\n])/,
+    punctuation: /[{}().,:?]/
+  };
+  Prism.languages.vb = Prism.languages["visual-basic"];
+  Prism.languages.vba = Prism.languages["visual-basic"];
+}
+
+export {
+  visualBasic
+};

package/dist/chunk-QVYDP4YF.mjs

@@ -0,0 +1,98 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/kumir.js
+kumir.displayName = "kumir";
+kumir.aliases = ["kum"];
+function kumir(Prism) {
+  ;
+  (function(Prism2) {
+    var nonId = /\s\x00-\x1f\x22-\x2f\x3a-\x3f\x5b-\x5e\x60\x7b-\x7e/.source;
+    function wrapId(pattern, flags) {
+      return RegExp(pattern.replace(/<nonId>/g, nonId), flags);
+    }
+    Prism2.languages.kumir = {
+      comment: {
+        pattern: /\|.*/
+      },
+      prolog: {
+        pattern: /#.*/,
+        greedy: true
+      },
+      string: {
+        pattern: /"[^\n\r"]*"|'[^\n\r']*'/,
+        greedy: true
+      },
+      boolean: {
+        pattern: wrapId(/(^|[<nonId>])(?:да|нет)(?=[<nonId>]|$)/.source),
+        lookbehind: true
+      },
+      "operator-word": {
+        pattern: wrapId(/(^|[<nonId>])(?:и|или|не)(?=[<nonId>]|$)/.source),
+        lookbehind: true,
+        alias: "keyword"
+      },
+      "system-variable": {
+        pattern: wrapId(/(^|[<nonId>])знач(?=[<nonId>]|$)/.source),
+        lookbehind: true,
+        alias: "keyword"
+      },
+      type: [
+        {
+          pattern: wrapId(
+            /(^|[<nonId>])(?:вещ|лит|лог|сим|цел)(?:\x20*таб)?(?=[<nonId>]|$)/.source
+          ),
+          lookbehind: true,
+          alias: "builtin"
+        },
+        {
+          pattern: wrapId(
+            /(^|[<nonId>])(?:компл|сканкод|файл|цвет)(?=[<nonId>]|$)/.source
+          ),
+          lookbehind: true,
+          alias: "important"
+        }
+      ],
+      /**
+       * Should be performed after searching for type names because of "таб".
+       * "таб" is a reserved word, but never used without a preceding type name.
+       * "НАЗНАЧИТЬ", "Фввод", and "Фвывод" are not reserved words.
+       */
+      keyword: {
+        pattern: wrapId(
+          /(^|[<nonId>])(?:алг|арг(?:\x20*рез)?|ввод|ВКЛЮЧИТЬ|вс[её]|выбор|вывод|выход|дано|для|до|дс|если|иначе|исп|использовать|кон(?:(?:\x20+|_)исп)?|кц(?:(?:\x20+|_)при)?|надо|нач|нс|нц|от|пауза|пока|при|раза?|рез|стоп|таб|то|утв|шаг)(?=[<nonId>]|$)/.source
+        ),
+        lookbehind: true
+      },
+      /** Should be performed after searching for reserved words. */
+      name: {
+        // eslint-disable-next-line regexp/no-super-linear-backtracking
+        pattern: wrapId(
+          /(^|[<nonId>])[^\d<nonId>][^<nonId>]*(?:\x20+[^<nonId>]+)*(?=[<nonId>]|$)/.source
+        ),
+        lookbehind: true
+      },
+      /** Should be performed after searching for names. */
+      number: {
+        pattern: wrapId(
+          /(^|[<nonId>])(?:\B\$[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)(?=[<nonId>]|$)/.source,
+          "i"
+        ),
+        lookbehind: true
+      },
+      /** Should be performed after searching for words. */
+      punctuation: /:=|[(),:;\[\]]/,
+      /**
+       * Should be performed after searching for
+       * - numeric constants (because of "+" and "-");
+       * - punctuation marks (because of ":=" and "=").
+       */
+      "operator-char": {
+        pattern: /\*\*?|<[=>]?|>=?|[-+/=]/,
+        alias: "operator"
+      }
+    };
+    Prism2.languages.kum = Prism2.languages.kumir;
+  })(Prism);
+}
+
+export {
+  kumir
+};

package/dist/chunk-QW6HJC6E.mjs

@@ -0,0 +1,72 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/python.js
+python.displayName = "python";
+python.aliases = ["py"];
+function python(Prism) {
+  Prism.languages.python = {
+    comment: {
+      pattern: /(^|[^\\])#.*/,
+      lookbehind: true,
+      greedy: true
+    },
+    "string-interpolation": {
+      pattern: /(?:f|fr|rf)(?:("""|''')[\s\S]*?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2)/i,
+      greedy: true,
+      inside: {
+        interpolation: {
+          // "{" <expression> <optional "!s", "!r", or "!a"> <optional ":" format specifier> "}"
+          pattern: /((?:^|[^{])(?:\{\{)*)\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}])+\})+\})+\}/,
+          lookbehind: true,
+          inside: {
+            "format-spec": {
+              pattern: /(:)[^:(){}]+(?=\}$)/,
+              lookbehind: true
+            },
+            "conversion-option": {
+              pattern: /![sra](?=[:}]$)/,
+              alias: "punctuation"
+            },
+            rest: null
+          }
+        },
+        string: /[\s\S]+/
+      }
+    },
+    "triple-quoted-string": {
+      pattern: /(?:[rub]|br|rb)?("""|''')[\s\S]*?\1/i,
+      greedy: true,
+      alias: "string"
+    },
+    string: {
+      pattern: /(?:[rub]|br|rb)?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/i,
+      greedy: true
+    },
+    function: {
+      pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g,
+      lookbehind: true
+    },
+    "class-name": {
+      pattern: /(\bclass\s+)\w+/i,
+      lookbehind: true
+    },
+    decorator: {
+      pattern: /(^[\t ]*)@\w+(?:\.\w+)*/m,
+      lookbehind: true,
+      alias: ["annotation", "punctuation"],
+      inside: {
+        punctuation: /\./
+      }
+    },
+    keyword: /\b(?:_(?=\s*:)|and|as|assert|async|await|break|case|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|match|nonlocal|not|or|pass|print|raise|return|try|while|with|yield)\b/,
+    builtin: /\b(?:__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\b/,
+    boolean: /\b(?:False|None|True)\b/,
+    number: /\b0(?:b(?:_?[01])+|o(?:_?[0-7])+|x(?:_?[a-f0-9])+)\b|(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)(?:e[+-]?\d+(?:_\d+)*)?j?(?!\w)/i,
+    operator: /[-+%=]=?|!=|:=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
+    punctuation: /[{}[\];(),.:]/
+  };
+  Prism.languages.python["string-interpolation"].inside["interpolation"].inside.rest = Prism.languages.python;
+  Prism.languages.py = Prism.languages.python;
+}
+
+export {
+  python
+};

package/dist/chunk-QWD3NTRK.mjs

@@ -0,0 +1,39 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/makefile.js
+makefile.displayName = "makefile";
+makefile.aliases = [];
+function makefile(Prism) {
+  Prism.languages.makefile = {
+    comment: {
+      pattern: /(^|[^\\])#(?:\\(?:\r\n|[\s\S])|[^\\\r\n])*/,
+      lookbehind: true
+    },
+    string: {
+      pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+      greedy: true
+    },
+    "builtin-target": {
+      pattern: /\.[A-Z][^:#=\s]+(?=\s*:(?!=))/,
+      alias: "builtin"
+    },
+    target: {
+      pattern: /^(?:[^:=\s]|[ \t]+(?![\s:]))+(?=\s*:(?!=))/m,
+      alias: "symbol",
+      inside: {
+        variable: /\$+(?:(?!\$)[^(){}:#=\s]+|(?=[({]))/
+      }
+    },
+    variable: /\$+(?:(?!\$)[^(){}:#=\s]+|\([@*%<^+?][DF]\)|(?=[({]))/,
+    // Directives
+    keyword: /-include\b|\b(?:define|else|endef|endif|export|ifn?def|ifn?eq|include|override|private|sinclude|undefine|unexport|vpath)\b/,
+    function: {
+      pattern: /(\()(?:abspath|addsuffix|and|basename|call|dir|error|eval|file|filter(?:-out)?|findstring|firstword|flavor|foreach|guile|if|info|join|lastword|load|notdir|or|origin|patsubst|realpath|shell|sort|strip|subst|suffix|value|warning|wildcard|word(?:list|s)?)(?=[ \t])/,
+      lookbehind: true
+    },
+    operator: /(?:::|[?:+!])?=|[|@]/,
+    punctuation: /[:;(){}]/
+  };
+}
+
+export {
+  makefile
+};

package/dist/chunk-QYRGAPSQ.mjs

@@ -0,0 +1,28 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/prolog.js
+prolog.displayName = "prolog";
+prolog.aliases = [];
+function prolog(Prism) {
+  Prism.languages.prolog = {
+    // Syntax depends on the implementation
+    comment: {
+      pattern: /\/\*[\s\S]*?\*\/|%.*/,
+      greedy: true
+    },
+    // Depending on the implementation, strings may allow escaped newlines and quote-escape
+    string: {
+      pattern: /(["'])(?:\1\1|\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1(?!\1)/,
+      greedy: true
+    },
+    builtin: /\b(?:fx|fy|xf[xy]?|yfx?)\b/,
+    // FIXME: Should we list all null-ary predicates (not followed by a parenthesis) like halt, trace, etc.?
+    function: /\b[a-z]\w*(?:(?=\()|\/\d+)/,
+    number: /\b\d+(?:\.\d*)?/,
+    // Custom operators are allowed
+    operator: /[:\\=><\-?*@\/;+^|!$.]+|\b(?:is|mod|not|xor)\b/,
+    punctuation: /[(){}\[\],]/
+  };
+}
+
+export {
+  prolog
+};

package/dist/chunk-RBSU2YDG.mjs

@@ -0,0 +1,143 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/javastacktrace.js
+javastacktrace.displayName = "javastacktrace";
+javastacktrace.aliases = [];
+function javastacktrace(Prism) {
+  Prism.languages.javastacktrace = {
+    // java.sql.SQLException: Violation of unique constraint MY_ENTITY_UK_1: duplicate value(s) for column(s) MY_COLUMN in statement [...]
+    // Caused by: java.sql.SQLException: Violation of unique constraint MY_ENTITY_UK_1: duplicate value(s) for column(s) MY_COLUMN in statement [...]
+    // Caused by: com.example.myproject.MyProjectServletException
+    // Caused by: MidLevelException: LowLevelException
+    // Suppressed: Resource$CloseFailException: Resource ID = 0
+    summary: {
+      pattern: /^([\t ]*)(?:(?:Caused by:|Suppressed:|Exception in thread "[^"]*")[\t ]+)?[\w$.]+(?::.*)?$/m,
+      lookbehind: true,
+      inside: {
+        keyword: {
+          pattern: /^([\t ]*)(?:(?:Caused by|Suppressed)(?=:)|Exception in thread)/m,
+          lookbehind: true
+        },
+        // the current thread if the summary starts with 'Exception in thread'
+        string: {
+          pattern: /^(\s*)"[^"]*"/,
+          lookbehind: true
+        },
+        exceptions: {
+          pattern: /^(:?\s*)[\w$.]+(?=:|$)/,
+          lookbehind: true,
+          inside: {
+            "class-name": /[\w$]+$/,
+            namespace: /\b[a-z]\w*\b/,
+            punctuation: /\./
+          }
+        },
+        message: {
+          pattern: /(:\s*)\S.*/,
+          lookbehind: true,
+          alias: "string"
+        },
+        punctuation: /:/
+      }
+    },
+    // at org.mortbay.jetty.servlet.ServletHandler$CachedChain.doFilter(ServletHandler.java:1166)
+    // at org.hsqldb.jdbc.Util.throwError(Unknown Source) here could be some notes
+    // at java.base/java.lang.Class.forName0(Native Method)
+    // at Util.<init>(Unknown Source)
+    // at com.foo.loader/foo@9.0/com.foo.Main.run(Main.java:101)
+    // at com.foo.loader//com.foo.bar.App.run(App.java:12)
+    // at acme@2.1/org.acme.Lib.test(Lib.java:80)
+    // at MyClass.mash(MyClass.java:9)
+    //
+    // More information:
+    // https://docs.oracle.com/en/java/javase/13/docs/api/java.base/java/lang/StackTraceElement.html#toString()
+    //
+    // A valid Java module name is defined as:
+    //   "A module name consists of one or more Java identifiers (§3.8) separated by "." tokens."
+    // https://docs.oracle.com/javase/specs/jls/se9/html/jls-6.html#jls-ModuleName
+    //
+    // A Java module version is defined by this class:
+    // https://docs.oracle.com/javase/9/docs/api/java/lang/module/ModuleDescriptor.Version.html
+    // This is the implementation of the `parse` method in JDK13:
+    // https://github.com/matcdac/jdk/blob/2305df71d1b7710266ae0956d73927a225132c0f/src/java.base/share/classes/java/lang/module/ModuleDescriptor.java#L1108
+    // However, to keep this simple, a version will be matched by the pattern /@[\w$.+-]*/.
+    "stack-frame": {
+      pattern: /^([\t ]*)at (?:[\w$./]|@[\w$.+-]*\/)+(?:<init>)?\([^()]*\)/m,
+      lookbehind: true,
+      inside: {
+        keyword: {
+          pattern: /^(\s*)at(?= )/,
+          lookbehind: true
+        },
+        source: [
+          // (Main.java:15)
+          // (Main.scala:15)
+          {
+            pattern: /(\()\w+\.\w+:\d+(?=\))/,
+            lookbehind: true,
+            inside: {
+              file: /^\w+\.\w+/,
+              punctuation: /:/,
+              "line-number": {
+                pattern: /\b\d+\b/,
+                alias: "number"
+              }
+            }
+          },
+          // (Unknown Source)
+          // (Native Method)
+          // (...something...)
+          {
+            pattern: /(\()[^()]*(?=\))/,
+            lookbehind: true,
+            inside: {
+              keyword: /^(?:Native Method|Unknown Source)$/
+            }
+          }
+        ],
+        "class-name": /[\w$]+(?=\.(?:<init>|[\w$]+)\()/,
+        function: /(?:<init>|[\w$]+)(?=\()/,
+        "class-loader": {
+          pattern: /(\s)[a-z]\w*(?:\.[a-z]\w*)*(?=\/[\w@$.]*\/)/,
+          lookbehind: true,
+          alias: "namespace",
+          inside: {
+            punctuation: /\./
+          }
+        },
+        module: {
+          pattern: /([\s/])[a-z]\w*(?:\.[a-z]\w*)*(?:@[\w$.+-]*)?(?=\/)/,
+          lookbehind: true,
+          inside: {
+            version: {
+              pattern: /(@)[\s\S]+/,
+              lookbehind: true,
+              alias: "number"
+            },
+            punctuation: /[@.]/
+          }
+        },
+        namespace: {
+          pattern: /(?:\b[a-z]\w*\.)+/,
+          inside: {
+            punctuation: /\./
+          }
+        },
+        punctuation: /[()/.]/
+      }
+    },
+    // ... 32 more
+    // ... 32 common frames omitted
+    more: {
+      pattern: /^([\t ]*)\.{3} \d+ [a-z]+(?: [a-z]+)*/m,
+      lookbehind: true,
+      inside: {
+        punctuation: /\.{3}/,
+        number: /\d+/,
+        keyword: /\b[a-z]+(?: [a-z]+)*\b/
+      }
+    }
+  };
+}
+
+export {
+  javastacktrace
+};